package cn.theten52.demo.patterns.design.behavior.interpreter.update2.reguar;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * 表示所有表达式的抽象接口
 *
 * @author wangjin
 * @date 2021/1/6
 */
interface Expression {

    /**
     * 计算表达式
     *
     * @param context 上下文
     */
    void evaluate(Context context);
}

/**
 * 根据Regex的功能操作符包括：Match、Replace两类操作
 */
enum RegExOperator {
    MATCH,
    REPLACE
}

/**
 * 用于保存计算过程的中间结果及当前执行的操作符
 */
class Context {
    ///文本内容
    private String content;

    ///匹配字符串集合
    private List<String> matches = new ArrayList<>();

    //操作类型
    private RegExOperator operator;

    //用于替换的文本内容
    private String replacement;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public List<String> getMatches() {
        return matches;
    }

    public RegExOperator getOperator() {
        return operator;
    }

    public void setOperator(RegExOperator operator) {
        this.operator = operator;
    }

    public String getReplacement() {
        return replacement;
    }

    public void setReplacement(String replacement) {
        this.replacement = replacement;
    }
}

/**
 * 所有表达式的抽象接口
 */
interface RegExpression extends Expression {
    /**
     * 为了简化示例，仅设计了正则表达式匹配判断的功能
     */
    boolean find(String expression);
}

//Java 为减轻每个具体正则表达式解析类型的负担而增加的抽象基类

/**
 * 所有表达式的抽象基类
 */
abstract class RegExpressionAbstract implements RegExpression {

    protected Pattern pattern;

    protected RegExpressionAbstract(String regex) {
        pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
    }

    /**
     * 实现Expression的接口要求
     */
    @Override
    public void evaluate(Context context) {
        evaluateInternal(context);
    }

    /**
     * 实现RegExpression的接口要求
     */
    @Override
    public boolean find(String expression) {
        return pattern.matcher(expression).find();
    }

    protected void evaluateInternal(Context context) {
        switch (context.getOperator()) {
            case MATCH:
                match(context);
                break;
            case REPLACE:
                replace(context);
                break;
        }
    }

    /**
     * 通过解析表达式确认字符串匹配
     * 可以被子类覆盖
     */
    protected void match(Context context) {
    }

    /**
     * 通过解析表达式替换字符串
     * 可以被子类覆盖
     */
    protected void replace(Context context) {
    }
}

// Java 通过不同表达式定义的解析类型

/**
 * 电子邮件
 * 具体表达式对象
 *
 * @author wangjin
 */
public class EmailRegExpression extends RegExpressionAbstract {
    public EmailRegExpression() {
        super("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
    }
}

/**
 * 汉字
 * 具体表达式对象
 */
class ChineseRegExpression extends RegExpressionAbstract {
    public ChineseRegExpression() {
        super("^[\\u4e00-\\u9fa5]{0,}$");
    }
}

/**
 * 普通的字符串
 * 具体表达式对象
 */
class StringRegExpression extends RegExpressionAbstract {
    public StringRegExpression(String regex) {
        super(regex);
    }
}